/*
 * 天虹商场股份有限公司版权所有.
 */
package org.tianyun.cloud.utils;

import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 正则表达式工具类
 *
 * @auther ebert_chan
 */
public class RegExUtils {

    /**
     * 通配符
     */
    public static final String WILDCARD = "*";

    public static final String DOT = "\\.";

    /**
     * 通配符解析表达式
     */
    public static final Pattern WILDCARD_PATTERN = Pattern.compile("^(.*?)(\\*+)(.*)$");

    /**
     * 检测字符串是否包含通配符
     *
     * @param key
     * @return boolean
     * @author ebert_chan
     */
    public static boolean containsWildcardCharacter(String key) {
        return key != null && key.contains(WILDCARD);
    }

    /**
     * 解析key中的通配符，通配符支持“*”，并转成正则表达式。
     *
     * @param character 字符串
     * @return java.util.regex.Pattern
     * @author ebert_chan
     */
    public static Pattern wildcardCharacterExpression(String character) {
        return wildcardCharacterExpression(character, null, true, true);
    }

    /**
     * 解析key中的通配符，通配符支持“*”和“**”，并转成正则表达式。
     * 多个“**”表示对整个字符串进行匹配，忽略分隔符；
     * 单个“*”且分隔符不为空，表示只在当前分段字符内匹配‘；
     * 当separator为空时，单个“*”表示的意思跟多个“**”相同。
     *
     * @param character 字符串
     * @param separator 字符串每段的分隔符，如abc.def.ghi，分隔符为"."
     * @return java.util.regex.Pattern
     * @author ebert_chan
     */
    public static Pattern wildcardCharacterExpression(String character, String separator, boolean matchStart, boolean matchEnd) {
        String text = character;
        Matcher matcher;

        StringBuilder buffer = new StringBuilder();
        if (matchStart) {
            buffer.append("^");
        }
        while ((matcher = WILDCARD_PATTERN.matcher(text)).find()) {
            String prefix = matcher.group(1);
            String symbol = matcher.group(2);
            text = matcher.group(3);

            if (StringUtils.hasLength(prefix)) {
                buffer.append(Pattern.quote(prefix));
            }

            if (WILDCARD.equals(symbol) && StringUtils.hasLength(separator)) {
                buffer.append("[^").append(separator).append("]*");
            } else {
                buffer.append(".*");
            }
        }

        if (StringUtils.hasLength(text)) {
            buffer.append(Pattern.quote(text));
        }

        if (matchEnd) {
            buffer.append("$");
        }

        return Pattern.compile(buffer.toString());
    }

    /**
     * 解析key中的通配符，通配符支持“*”和“**”，从通配符处截断分隔字符，返回各段字符的列表(包含通配符)。
     *
     * @param character 字符串
     * @return java.util.regex.Pattern
     * @author ebert_chan
     */
    public static List<String> splitWildcardCharacter(String character) {
        String text = character;
        Matcher matcher;

        List<String> buffer = new ArrayList<>();

        while ((matcher = WILDCARD_PATTERN.matcher(text)).find()) {
            String prefix = matcher.group(1);
            String symbol = matcher.group(2);
            text = matcher.group(3);

            if (StringUtils.hasLength(prefix)) {
                buffer.add(prefix);
            }

            buffer.add(symbol);
        }

        if (StringUtils.hasLength(text)) {
            buffer.add(text);
        }

        return buffer;
    }

    /**
     * 解析key中的通配符，通配符支持“*”和“**”，从通配符处截断分隔字符并转换为正则表达式。
     *
     * @param character 字符串
     * @param separator 字符串每段的分隔符，如abc.def.ghi，分隔符为"."
     * @return java.util.regex.Pattern
     * @author ebert_chan
     */
    public static List<Pattern> splitWildcardCharacterToPattern(String character, String separator) {
        List<String> list = splitWildcardCharacter(character);
        List<Pattern> patterns = new ArrayList<>();
        for (String subsection : list) {
            patterns.add(wildcardCharacterExpression(subsection, separator, true, false));
        }
        return patterns;
    }

}
